
package com.rt.schedulenew.utils.base;

import lombok.Getter;
import org.apache.commons.lang3.ObjectUtils;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class ConstantsUtil {
    public static SimpleDateFormat YMDHMS;
    public static SimpleDateFormat YMDHM;
    public static String SCHEDULE_CONFIG_KEY = "SCHEDULE_CONFIG";
    public static String CURRENT_USER = "session.current.user";
    public static String NO_LOGIN = "nologin";
    public static String ADMIN_USERID = "ADMIN";
    public static String SCHEDULE_STATUS_ZERO = "0";
    public static String SCHEDULE_STATUS_ONE = "1";
    public static String SCHEDULE_ACT_DESC_TEMPLATE_CANCEL_SIGN_OVERTIME = "由于您未在必须到达时间{REQ_REACH_TIME}前报到，系统于{ACT_DATE}自动取消了申请单号为{APPLY_NO}的{EXAM_CLASS}类别的检查预约。";
    public static String SCHEDULE_ACT_DESC_TEMPLATE_CANCEL_NOCHARGE = "由于您未在{MINUTES}分钟内结算，系统于{ACT_DATE}自动取消了申请单号为{APPLY_NO}的{EXAM_CLASS}类别的检查预约。";


    static {
        YMDHMS = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        YMDHM = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    }

    public enum CardInputSupportField {
        IC_CARD("ic_card", "诊疗卡号"),
        INPATIENT_NO("inpatient_no", "住院号"),
        OUTPATIENT_NO("outpatient_no", "门诊好"),
        APPLY_NO("apply_no", "申请单号"),
        IDENTITY_CARD("identity_card", "身份证号"),
        MI_CARD("mi_card", "医保卡号"),
        SICK_ID("sick_id", "患者标识号"),
        HEALTH_CARD("health_card", "健康卡号"),
        OUT_REG_NO("out_reg_no", "挂号号"),
        CASE_NO("case_no", "病案编号");

        CardInputSupportField(String key, String name) {
            this.key = key;
            this.name = name;
        }

        private String key;
        private String name;

    }

    /***
     * 提醒类型
     */
    public enum ReminderType {
        SCHEDULE("REMINDER_SCHEDULE"),
        SIGN("REMINDER_SIGN");

        private String type;

        private ReminderType(String type) {
            this.type = type;
        }

        public String getType() {
            return this.type;
        }
    }

    /***
     * 操作类型
     */
    public enum ActType {

        /**
         * 废除清单
         */
        DEL_ITEM("C", "废除申请单"),
        /**
         * 锁定
         */
        LOCK("L", "锁定"),
        /**
         * 【释放锁定的号源】
         */
        UN_LOCK("U", ""),
        /**
         * 解锁黑名单
         */
        UNLOCK("B", "解锁黑名单"),
        /**
         * 预约
         */
        CONFIRM("0", "预约"),
        /**
         * 修改
         */
        UPDATE("1", "修改"),
        /**
         * 【取消预约】
         */
        CANCEL("2", "取消预约"),
        /**
         * 报到
         */
        SIGN("3", "报到"),
        /**
         * 【废除申请单】
         */
        DEL_APPLY("4", "废除申请单"),
        /**
         * 取消报到
         */
        CANCEL_SIGN("5", "取消报到"),
        /**
         * 检查
         */
        EXAM("6", "检查"),
        /**
         * 绿色通道
         */
        NO_REGULAR("7", "绿色通道"),
        /**
         * 打印预约凭条
         */
        SCHE_PRINT("8", "打印预约凭条"),
        /**
         * 打印预约清单
         */
        INVENTORY("9", "打印预约清单"),
        /**
         * 打印报到凭条
         */
        SIGN_PRINT("10", "打印报到凭条"),
        /**
         * 确认消息
         */
        NOTICE_AFFIRM("11", "确认消息"),
        /**
         * 修改申请单
         */
        EDIT_APPLY("99", "修改申请单");


        @Getter
        private final String type;
        /**
         * 助记说明
         */
        private final String mome;

        ActType(String type, String mome) {
            this.type = type;
            this.mome = mome;
        }

    }

    /**
     * 人员类型
     */
    @Getter
    public enum UserType {
        PATIENT("1"),
        DOCTOR("2"),
        SYSTEM("3");

        private final String type;

        UserType(String type) {
            this.type = type;
        }

    }

    /**
     * 操作设备类型
     */
    @Getter
    public enum TerminalType {
        /**
         * 管理平台-【医技科室端】
         */
        DEPT("A", "医技预约"),
        /**
         * 临床医生端
         */
        CLINIC_IN("B", "临床住院"),
        /**
         * 自助机
         */
        SELF("C", "自助机"),
        /**
         * 移动端
         */
        MOBILE("D", "手机"),

        /**
         * 预约中心端
         */
        SCHEDULE_CENTER("E", "预约中心端"),
        /**
         * 预约管理端
         */
        SCHEDULE_MANAGE("F", "预约管理端"),
        /**
         * 系统
         */
        SYSTEM("G", "系统"),
        /**
         * 其他程序
         */
        OTHER("O", "其他程序"),
        /**
         * 临床门诊
         */
        CLINIC_OUT("H", "临床门诊");

        private final String type;
        private final String value;

        TerminalType(String type, String value) {
            this.type = type;
            this.value = value;
        }

    }

    public enum CountType {
        YEAR,
        MONTH,
        DATE;
    }

    /**
     * 午别时段字典
     */
    @Getter
    public enum DictScheduleApmFlag {
        MORNING("0", "上午"),
        AFTERNOON("1", "下午"),
        NIGHT("2", "晚上"),
        ALLDAY("3", "全天"),
        NOON("4", "中午");

        private final String key;
        private final String value;

        DictScheduleApmFlag(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static DictScheduleApmFlag get(String key) {
            DictScheduleApmFlag[] values;
            DictScheduleApmFlag[] errorCodes = values = values();
            for (DictScheduleApmFlag obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }
    }

    public enum ItemFlags {
        UNSCHEDULE("0", "不预约"),
        CLAM("1", "镇静"),
        ENHANCE("2", "增强"),
        EMPTYSTOMACH("3", "空腹"),
        BERNAO("4", "憋尿"),
        PUNCTURE("5", "穿刺"),
        NOSIGNSELF("6", "不允许自助报到"),
        ONLYDEPTSCHESCHEDULE("7", "只能医技前台预约");

        public final String key;
        public final String value;

        ItemFlags(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static ItemFlags get(String key) {
            ItemFlags[] values = values();
            for (ItemFlags obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }
    }

    /**
     * 预约状态
     */
    @Getter
    public enum ScheduleStatus {
        ZERO("0"),
        ONE("01"),
        TWO("02"),
        FOUR("04"),
        SIX("06"),
        EIGHT("08"),
        TEN("10"),
        FORTY("40"),
        NINE("09"),
        ZEROZERO("00");

        private final String status;

        ScheduleStatus(String status) {
            this.status = status;
        }

        public String getStatus() {
            return this.status;
        }
    }

    /**
     * 操作名称
     */
    @Getter
    public enum OperateName {
        INSERT("新增"),
        UPDATE("修改"),
        DELETE("删除"),
        OPEN("启用"),
        STOP("停用");

        private final String desc;

        OperateName(String desc) {
            this.desc = desc;
        }

        public String getDesc() {
            return this.desc;
        }

        public static String get(String name) {
            OperateName findFirst = Arrays.stream(values())
                    .filter(x -> x.getDesc().equals(name)).findFirst().orElse(null);
            if (Objects.nonNull(findFirst)) {
                return findFirst.getDesc();
            }
            return null;
        }
    }

    public static void main(String[] args) {
        System.out.println(OperateName.UPDATE.name());
    }

    /**
     * 模块名称
     */
    @Getter
    public enum ModuleName {
        /**
         * 通用号源
         */
        DICT_SCHEDULE_APM_COMMON("DICT_SCHEDULE_APM_COMMON", "通用号源"),
        /**
         * 星期号源
         */
        DICT_SCHEDULE_APM_WEEK("DICT_SCHEDULE_APM_WEEK", "星期号源"),
        /**
         * 日期号源
         */
        DICT_SCHEDULE_APM_DATE("DICT_SCHEDULE_APM_DATE", "日期号源"),
        /**
         * 预约规则
         */
        DICT_SCHEDULE_REGULAR_DEF("DICT_SCHEDULE_REGULAR_DEF", "预约规则"),
        /**
         * 预约队列
         */
        DICT_SCHEDULE_QUEUE("DICT_SCHEDULE_QUEUE", "预约队列"),
        /**
         * 检查项目
         */
        DICT_EXAM_ITEM("DICT_EXAM_ITEM", "检查项目"),
        /**
         * 项目分组
         */
        ITEM_GROUP("ITEM_GROUP", "项目分组"),

        /**
         * 友情提示
         */
        DICT_REMINDER("DICT_REMINDER", "友情提示"),

        /**
         * 检查队列
         */
        DICT_EXAM_QUEUE("DICT_EXAM_QUEUE", "检查队列"),
        /**
         * 预约时段
         */
        DICT_SCHEDULE_APM("DICT_SCHEDULE_APM", "预约时段");

        private final String name;
        private final String desc;

        ModuleName(String name, String desc) {
            this.name = name;
            this.desc = desc;
        }

        public String getDesc() {
            return this.desc;
        }

        public String getName() {
            return name;
        }

        /**
         * 获取全部的模块名称
         *
         * @return
         */
        public static List<String> getAllModuleName() {
            return Arrays.stream(values()).map(x -> x.getName())
                    .collect(Collectors.toList());
        }


        /**
         * 获取全部的模块名称
         *
         * @return
         */
        public static List<String> getDictModuleName() {
            List<ModuleName> dictModule = Arrays.asList(ModuleName.DICT_REMINDER, ModuleName.DICT_EXAM_QUEUE, ModuleName.ITEM_GROUP, ModuleName.DICT_SCHEDULE_REGULAR_DEF, ModuleName.DICT_SCHEDULE_QUEUE);
            return dictModule.stream()
                    .filter(x -> x.getName().startsWith("DICT_"))
                    .map(x -> x.getName())
                    .collect(Collectors.toList());
        }

        public static String get(String name) {
            ModuleName[] values = values();
            for (ModuleName obj : values) {
                if (obj.name().equals(name)) {
                    return obj.desc;
                }
            }
            return null;
        }
    }

    public enum EhCacheName {
        tokenCache,
        /**
         * 预约规则缓存
         */
        regularCache,
        sourceCache,
        ruleResultCache,
        /**
         * 自动任务缓存
         */
        scheduleTask,
        /**
         * 登录失败次数
         */
        loginFail,
        /**
         * 诊室轮换
         */
        roomCache;
    }

    public enum EhCacheKey {
        /**
         * 时段数量规则缓存
         */
        APM_REGULAR_INFO("%s-3", "时段数量规则缓存");

        private String key;
        private String memo;

        EhCacheKey(String key, String memo) {
            this.key = key;
            this.memo = memo;
        }

        public String getKey() {
            return key;
        }
    }

    /***
     * 性别
     */
    public enum Gender {
        MAN("0", "男"),
        WOMAN("1", "女"),
        OTHER("2", "其他");

        private String key;
        private String value;

        Gender(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static Gender get(String key) {
            Gender[] values = values();
            for (Gender obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }

    /**
     * 配置大项枚举
     */
    public enum ConfigType {
        INFO_SYNC("infoSync", "信息与同步"),
        SCHEDULE("schedule", "预约"),
        SIGN("sign", "报到"),
        OTHER("other", "其他配置"),
        CONFLICT("conflict", "冲突配置"),
        INTERFACE("interface", "界面与显示"),

        /***
         * 打印配置
         */
        PRINT("print", "打印配置"),

        /***
         * 检索和表格
         */
        SEARCHES_FORM("searchesForm", "检索和表格"),
        CUSTOM_LIST("customList", "待删除"),
        CLINICSCHE("clinicsche", "临床配置");

        private String key;
        private String value;

        ConfigType(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static ConfigType get(String key) {
            ConfigType[] values = values();
            for (ConfigType obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }
    }

    /**
     * 配置小项目枚举
     */
    public enum ConfigName {
        IC_CARD_PRES("yy_icCardPres", "传入的ic卡号加前缀"),

        /***
         * 【卡号栏查询支持类型】ic_card(诊疗卡号),inpatient_no(住院号),outpatient_no(门诊号),apply_no(申请单号),identity_card(身份证号),mi_card(医保卡号),sick_id(病人标识号),health_card(健康卡号),out_reg_no(挂号号),case_no(病案编号)
         */
        IC_CARD_INPUT_SUPPORT("yy_icCardInputSupport",
                "【卡号栏查询支持类型】ic_card(诊疗卡号),inpatient_no(住院号),outpatient_no(门诊号),apply_no(申请单号),identity_card(身份证号),mi_card(医保卡号),sick_id(病人标识号),health_card(健康卡号),out_reg_no(挂号号),case_no(病案编号)"),
        /**
         * 【住院病人来源名称】
         */
        PATIENT_SOURCE_IN("yy_patientSourceIn", "【住院病人名称】"),
        /**
         * 【实时获取缴费单标识】(1：关闭   0：启用)
         */
        IS_GET_CHARGE_FLAG_REALTIME("yy_isGetChargeFlagRealTime", "【实时获取缴费单标识】(1：关闭   0：启用)"),
        IS_GET_ACCOUNT_BALANCE_REALTIME("yy_isGetAccountBalanceRealTime", ""),
        IS_GET_CLINIC_PATH_FLAG_REALTIME("yy_isGetClinicPathFlagRealTime", ""),
        /**
         * 【同步给第三方预约信息】(1：关闭   0：启用)，grant：表示是否启用同步给第三方预约信息，isSyncScheduleRealTime：表示是否实时同步预约信息至第三方，isSyncRefer：表示是否同步虚单，syncUrl：表示接口地址，syncInfoSet：表示同步设置相关参数：syncExamClass：同步检查类别，syncAct：同步操作
         */
        IS_NOTIFY_THIRD_AFTER_SCHEDULE("yy_isNotifyThirdAfterSchedule", "【同步给第三方预约信息】(1：关闭   0：启用)，grant：表示是否启用同步给第三方预约信息，isSyncScheduleRealTime：表示是否实时同步预约信息至第三方，isSyncRefer：表示是否同步虚单，syncUrl：表示接口地址，syncInfoSet：表示同步设置相关参数：syncExamClass：同步检查类别，syncAct：同步操作"),
        EXAM_APPLY_INFO_SUPPORT("yy_examApplyInfoSupport", ""),
        /**
         * 【调用第三方HIS实时获取缴费单标识接口的链接】注：使用的前提是[yy_isGetChargeFlagRealTime]该配置项要启用！
         */
        GET_CHARGE_FLAG_REALTIME_URL("yy_getChargeFlagRealTimeUrl", ""),
        GET_ACCOUNT_BALANCE_REALTIME_URL("yy_getAccountBalanceRealTimeUrl", ""),
        IS_IC_CARD_INPUT_NEW_SUPPORT("yy_isIcCardInputNewSupport", "卡号栏查询支持类型"),
        /**
         * 【是否启用虚单实时获取患者信息】(1：关闭   0：启用)，getReferPatientInfoUrl：虚单实时获取患者信息的链接地址
         */
        IS_GET_REFER_PATIENT_INFO("yy_isGetReferPatientInfo", "【是否启用虚单实时获取患者信息】(1：关闭   0：启用)，getReferPatientInfoUrl：虚单实时获取患者信息的链接地址"),
        /**
         * 【对卡号进行转换，返回院内能识别的卡号】
         * 0：调DLL，1：关闭，2：调第三方接口
         */
        IS_VIRTUAL_CARD_READER("yy_isVirtualCardReader", "【对卡号进行转换，返回院内能识别的卡号】0：调DLL，1：关闭，2：调第三方接口"),
        /**
         * 【通用患者卡查询接口地址】注：使用的前提是[yy_isVirtualCardReader]该配置项的值等于2
         */
        VIRTUAL_CARD_READER_URL("yy_virtualCardReaderUrl", "【通用患者卡查询接口地址】注：使用的前提是[yy_isVirtualCardReader]该配置项的值等于2"),
        IS_INPUT_NEW_SUPPORT("yy_isInputNewSupport", ""),
        /**
         * 【接口超时断连时间】只填数值（单位：秒）
         */
        HTTP_TIMEOUT("yy_httpTimeout", "【接口超时断连时间】只填数值（单位：秒）"),
        /**
         * 【卡号栏输入字母转化为大写进行查询】(1：关闭   0：启用)
         */
        IS_UPPER_CASE_INPUT("yy_isUpperCaseInput", "【卡号栏输入字母转化为大写进行查询】(1：关闭   0：启用)"),
        /**
         * 启用临床调用时经过token验证
         */
        IS_TOKEN_OAUTH_BY_CLINIC("yy_isTokenOauthByClinic", "启用临床调用时经过token验证"),
        OPEN_THIRD_URL("yy_openThirdUrl", ""),
        /**
         * 【启用消息提醒(一级消息logo)】(1：关闭   0：启用)
         */
        IS_MESSAGE_ALERT("yy_isMessageAlert", "【启用消息提醒(一级消息logo)】(1：关闭   0：启用)"),
        /**
         * 【启用住院患者的申请单在修改预约与取消预约时，给申请单病区所关联的科室的用户发送消息提醒(二级提示内容)】(1：关闭   0：启用)
         */
        IS_MESSAGE_ALERT_BY_WARD("yy_isMessageAlertByWard", "【启用住院患者的申请单在修改预约与取消预约时，给申请单病区所关联的科室的用户发送消息提醒(二级提示内容)】(1：关闭   0：启用)"),
        /**
         * 【根据终端，默认申请科室及病区】(1：关闭   0：启用)
         * 【根据终端，默认申请科室及病区】(1：关闭   0：启用)，terminalType：终端类型，暂支持A-医技预约  B-临床预约  E-预约中心
         */
        IS_DEPT_WARD_DEFAULT_BY_TERMINAL_TYPE("yy_isDeptWardDefaultByTerminalType", "【根据终端，默认申请科室及病区】(1：关闭   0：启用)"),
        /**
         * 【默认科室开启后，限制更改科室及病区】(1：关闭   0：启用)
         */
        IS_EDIT_DEPT_WARD_LIMIT("yy_isEditDeptWardLimit", "【默认科室开启后，限制更改科室及病区】(1：关闭   0：启用)"),
        REQ_DATE_DEFAULT_BY_SCHEDULE("yy_reqDateDefaultBySchedule", ""),
        REQ_DATE_DEFAULT_BY_QUERY("yy_reqDateDefaultByQuery", ""),
        /**
         * 不预约的检查类别】(多个用英文逗号“,”分隔)
         */
        NOT_EXAM_CLASS("yy_notExamClass", "不预约的检查类别】(多个用英文逗号“,”分隔)"),
        IS_SHOW_CHARGE_FLAG("yy_isShowChargeFlag", ""),
        /**
         * 【是否启用确认预约时判断确费】(1：关闭   0：启用)
         */
        IS_CONFIRM_FEE_BEFORE_SCHEDULE("yy_isConfirmFeeBeforeSchedule", "【是否启用确认预约时判断确费】(1：关闭   0：启用)"),
        CHARGE_AFTER_EXAM_CLASS("yy_chargeAfterExamClass", ""),
        /**
         * 【限制先缴费后预约的检查类别】(多个用英文逗号“,”分隔)
         */
        CHARGE_FIRST_EXAM_CLASS("yy_chargeFirstExamClass", "【限制先缴费后预约的检查类别】(多个用英文逗号“,”分隔)"),
        /**
         * 【限制先缴费后预约的病人来源】(多个用英文逗号“,”分隔)
         */
        CHARGE_FIRST_PATIENT_SOURCE("yy_chargeFirstPatientSource", "【限制先缴费后预约的病人来源】(多个用英文逗号“,”分隔)"),
        CANCEL_SCHEDULE_NO_CHARGE_MIN("yy_cancelScheduleNoChargeMin", ""),
        CANCEL_SCHEDULE_NO_CHARGE("yy_cancelScheduleNoCharge", ""),
        /**
         * 【自动预约延缓时长】(1：关闭   0：启用)，patientSource：表示病人来源，delayTime：表示延缓时长（单位：分钟）
         */
        AUTO_SCHEDULE_DELAY_TIME("yy_autoScheduleDelayTime", "【自动预约延缓时长】(1：关闭   0：启用)，patientSource：表示病人来源，delayTime：表示延缓时长（单位：分钟）"),
        /**
         * 【过滤历史申请单时间点】(1：关闭   0：启用)，validDate：表示历史申请单时间（格式：yyyy-MM-dd）");
         */
        IS_VALID_DATE("yy_isValidDate", "【过滤历史申请单时间点】(1：关闭   0：启用)，validDate：表示历史申请单时间（格式：yyyy-MM-dd）\");"),
        /**
         * 【“已取消”预约状态】(1：关闭   0：启用)，注：对“未预约”申请单细分为“已取消”，且该预约状态的申请单不推荐预约时间
         */
        IS_CANCEL_FLAG("yy_isCancelFlag", "【“已取消”预约状态】(1：关闭   0：启用)，注：对“未预约”申请单细分为“已取消”，且该预约状态的申请单不推荐预约时间"),
        IS_SCHEDULE_PLAN_BY_DEPTSCHE("yy_isSchedulePlanByDeptsche", ""),
        IS_SCHEDULE_PLAN_BY_CLINIC("yy_isSchedulePlanByClinic", ""),
        IS_SCHEDULE_QUERY_TO_CLINIC("yy_isScheduleQueryToClinic", ""),
        IS_SHOW_NOTICE("yy_isShowNotice", ""),
        IS_RECORD_NOTES_BY_CANCEL("yy_isRecordNotesByCancel", ""),
        /**
         * 【按项目预约量系数占号的检查类别】(多个用英文逗号“,”分隔)
         */
        ORGAN_EXAM_CLASS("yy_organExamClass", "【按项目预约量系数占号的检查类别】(多个用英文逗号“,”分隔)"),

        /**
         * 【启用跨院区预约的检查类别】(多个用英文逗号“,”分隔)
         */
        SPAN_HOSPITAL_EXAM_CLASS("yy_spanHospitalExamClass", "【启用跨院区预约的检查类别】(多个用英文逗号“,”分隔)"),
        /**
         * 【按病人来源开放预约天数限制】(1：关闭   0：启用)，patientSource：表示病人来源；expireDay：表示开放预约天数限制，单位为天，空值时不受限制；[注：当“预约管理》预约队列”的开放预约天数没有配置时，才会使用到这里的开放预约天数的配置]
         */
        EXPIRE_DAY_BY_PATIENT_SOURCE("yy_expireDayByPatientSource", "【按病人来源开放预约天数限制】(1：关闭   0：启用)，patientSource：表示病人来源；expireDay：表示开放预约天数限制，单位为天，空值时不受限制；[注：当“预约管理》预约队列”的开放预约天数没有配置时，才会使用到这里的开放预约天数的配置]"),
        /**
         * 运送工具类型
         */
        TRANS_TOOL("yy_transTool", ""),
        /**
         * 【“预约成功”短信通知】(1：关闭   0：启用)
         */
        IS_SMS_NOTICE_FOR_SCHEDULE("yy_isSmsNoticeForSchedule", "【“预约成功”短信通知】(1：关闭   0：启用)"),
        IS_SMS_NOTICE_FOR_DEL_SCHEDULE("yy_isSmsNoticeForDelSchedule", "【“取消预约”短信通知】(1：关闭   0：启用)"),
        SMS_NOTICE_PATIENT_SOURCE("yy_smsNoticePatientSource", "【按病人来源开启短信通知】"),
        SMS_NOTICE_QUEUE("yy_smsNoticeQueue", "【按队列开启短信通知】"),
        NEED_CONFIRM_ITEM("yy_needConfirmItem", "【患者预约需要审核的检查项目】"),
        PRINT_TICKET_AFTER_SCHEDULE("yy_printTicketAfterSchedule", "【预约成功后，可根据终端类型、检查类别、病人来源自动打印预约凭条】printTicketTerminalType：表示预约凭条终端类型；printTicketExamClass：表示预约凭条检查类别；printTicketPatientSource：表示预约凭条病人来源；"),
        SELF_REQ_DATE_LIMIT("yy_selfReqDateLimit", ""),
        /**
         * 【是否开启调用获取第三方HIS的申请单接口】(1：关闭   0：启用)，applyUrl：表示第三方HIS接口服务的链接地址
         */
        IS_GET_HIS_APPLY_BY_THIRD_WS("yy_isGetHisApplyByThirdWS", "【是否开启调用获取第三方HIS的申请单接口】(1：关闭   0：启用)，applyUrl：表示第三方HIS接口服务的链接地址"),
        /**
         * 【是否启用取消预约调用退费接口】(1：关闭   0：启用)，recedeCostUrl：表示第三方退费接口的链接地址
         */
        IS_RECEDE_COST_BY_CANCEL("yy_isRecedeCostByCancel", "【是否启用取消预约调用退费接口】(1：关闭   0：启用)，recedeCostUrl：表示第三方退费接口的链接地址"),
        CHARGE_AFTER_SCHEDULE_URL("yy_chargeAfterScheduleUrl", ""),
        CONFIRM_FEE_BEFORE_SCHEDULE_URL("yy_confirmFeeBeforeScheduleUrl", ""),
        REMIND_PRINT_TICKET_AFTER_SCHEDULE("yy_remindPrintTicketAfterSchedule", "【预约成功后，可根据终端类型、检查类别、病人来源提醒是否要打印凭条】printTicketTerminalType：表示预约凭条终端类型；printTicketExamClass：表示预约凭条检查类别；printTicketPatientSource：表示预约凭条病人来源；"),
        MERGE_ITEM("yy_mergeItem", ""),
        QUEUE_NO_CLASS("yy_queueNoClass", "【预约生成排队号的检查类别，非预约立即取号流程,会调用ST_GetQueueNo函数生成，空不生成】(多个用英文逗号“,”分隔)"),
        NO_REGULAR_QUEUE_NO_CLASS("yy_noRegularQueueNoClass", "【绿色通道生成排队号的检查类别】(多个用英文逗号“,”分隔)"),
        /**
         * 【取消预约号源不释放】examClass：表示提前报到释放号源的检查类别；leadTime：表示提前时间（界面选什么，就怎样去存进数据库）；
         */
        NO_FREE_SOURCE_BY_CANCEL("yy_noFreeSourceByCancel", "【取消预约号源不释放】examClass：表示提前报到释放号源的检查类别；leadTime：表示提前时间（界面选什么，就怎样去存进数据库）；"),
        /**
         * 需要在预约前选择更新无痛标识的项目】
         */
        EDIT_ITEM_FLAG_BEFORE_SCHEDULE("yy_editItemFlagBeforeSchedule", "【需要在预约前选择更新无痛标识的项目】"),
        NO_SHOW_UN_SCHEDULE_ITEM_BY_TERMINAL_TYPE("yy_noShowUnScheduleItemByTerminalType", ""),
        IS_SPAN_HOSPITAL_EXAM_CLASS_BY_GREEN_CHANNEL("yy_isSpanHospitalExamClassByGreenChannel", ""),
        /**
         * 【根据检查类别，申请单的电话号码是否为必填】(多个用英文逗号“,”分隔)
         */
        CHECKOUT_PHONE_NUMBER_BY_EXAM_CLASS("yy_checkOutPhoneNumberByExamClass", "【根据检查类别，申请单的电话号码是否为必填】(多个用英文逗号“,”分隔)"),
        /**
         * 【是否显示申请单数量】(1：不显示   0：显示)
         */
        IS_SHOW_APPLY_NUMBER("yy_isShowApplyNumber", "【是否显示申请单数量】(1：不显示   0：显示)"),
        CANCEL_SCHEDULE_NO_CHARGE_BY_TIME("yy_cancelScheduleNoChargeByTime", ""),
        MERGE_FULL_MATCH_EXAM_CLASS("yy_mergeFullMatchExamClass", ""),
        MERGE_PART_MATCH_EXAM_CLASS("yy_mergePartMatchExamClass", ""),
        /**
         * 【以天数为单位判断队列优先级的类别】(多个用英文逗号“,”分隔)
         */
        FIRST_SCHE_PRIORITY_QUEUE_BY_ONE_DAY("yy_firstSchePriorityQueueByOneDay", "【以天数为单位判断队列优先级的类别】(多个用英文逗号“,”分隔)"),
        /**
         * 【限制自助端操作（包括自助机与移动端）】
         * examClass：表示限制操作的检查类别，
         * limitTime：表示限制操作的时间，
         * limitAct：表示限制操作
         */
        SELF_ACT_LIMIT("yy_selfActLimit", ""),
        NEED_CLAM_AGE_BY_ITEM("yy_needClamAgeByItem", ""),
        CHARGE_FIRST_SCHEDULE_URL("yy_chargeFirstScheduleUrl", ""),
        IS_CONFIRM_SCHEDULE_BY_IGNORE_DIALOG("yy_isConfirmScheduleByIgnoreDialog", ""),
        /**
         * 预约终端限制
         * 【自助端修改预约（改约）限制次数】
         * examClass：表示限制预约（改约）的检查类别，
         * terminalType：表示限制预约（改约）的终端类型，
         * limitCount：表示限制预约（改约）的次数
         */
        SCHEDULE_LIMIT_BY_TERMINAL("yy_scheduleLimitByTerminal", ""),

        CONFIRM_FEE_BEFORE_SCHEDULE_EXAM_CLASS("yy_confirmFeeBeforeScheduleExamClass", ""),
        CONFIRM_FEE_BEFORE_SCHEDULE_PATIENT_SOURCE("yy_confirmFeeBeforeSchedulePatientSource", ""),
        IS_NOT_UPDATE_CHARGE_FLAG_BY_CONFIRM_FEE("yy_isNotUpdateChargeFlagByConfirmFee", ""),
        IS_NOT_UPDATE_CHARGE_FLAG_BY_RECEDE_COST("yy_isNotUpdateChargeFlagByRecedeCost", ""),
        IS_OPEN_DEL_APPLY_BTN("yy_isOpenDelApplyBtn", ""),
        /**
         * 【镇静申请单只可预约相应时长后的时段】examClass：表示检查类别，limitTime：表示只能预约“N”小时之后(带单位时间)
         */
        ONLY_MATCH_APM_BY_CLAM_APPLY("yy_onlyMatchApmByClamApply", "【镇静申请单只可预约相应时长后的时段】examClass：表示检查类别，limitTime：表示只能预约“N”小时之后(带单位时间)"),
        /**
         * 【是否启用改约/取消/修改申请单时需填密码(医技端)】(1：关闭   0：启用),注：密码是登录账户的密码
         */
        IS_NEED_PASSWORD_BY_DEPTSCHE("yy_isNeedPasswordByDeptsche", "【是否启用改约/取消/修改申请单时需填密码(医技端)】(1：关闭   0：启用),注：密码是登录账户的密码"),
        NEED_PASSWORD_EXAM_CLASS_BY_DEPTSCHE("yy_needPasswordExamClassByDeptsche", ""),
        /**
         * 【限制先缴费后预约的终端类型】(多个用英文逗号“,”分隔)
         */
        CHARGE_FIRST_TERMINAL_TYPE("yy_chargeFirstTerminalType", "【限制先缴费后预约的终端类型】(多个用英文逗号“,”分隔)"),
        /**
         * 【隐藏【仅医技前台预约】的项目的终端】(多个用英文逗号“,”分隔)
         */
        NO_SHOW_ONLY_DEPTSCHE_SCHEDULE_BY_TERMINAL_TYPE("yy_noShowOnlyDeptscheScheduleByTerminalType", "【隐藏【仅医技前台预约】的项目的终端】(多个用英文逗号“,”分隔)"),
        /**
         * 【启用定时调用自动预约】(1：关闭   0：启用)
         */
        IS_AUTO_SCHEDULE_BY_TIMING_TASK("yy_isAutoScheduleByTimingTask", "【启用定时调用自动预约】(1：关闭   0：启用)"),
        /**
         * 【定时调用自动预约】注：使用的前提是[yy_isAutoScheduleByTimingTask]该配置项已启用,examClass:检查类别,patientSource:病人来源,filterFlag:过滤申请单,limitTime:时间点,day:申请单日期范围
         */
        AUTO_SCHEDULE_BY_TIMING_TASK("yy_autoScheduleByTimingTask", "【定时调用自动预约】注：使用的前提是[yy_isAutoScheduleByTimingTask]该配置项已启用,examClass:检查类别,patientSource:病人来源,filterFlag:过滤申请单,limitTime:时间点,day:申请单日期范围"),
        /**
         * 【开启配置前提下，根据院区代码调用获取第三方HIS的申请单接口】(多个用英文逗号“,”分隔)注：使用的前提是[yy_isGetHisApplyByThirdWS]该配置项已启用
         */
        GET_HIS_APPLY_BY_HOSPITAL("yy_getHisApplyByHospital", ""),
        SCHEDULE_STATUS_BY_CONFIRM_FEE("yy_scheduleStatusByConfirmFee", ""),
        /**
         * 【点击打印按钮1次，打印多少张】默认为1张
         */
        CLICK_BTN_BY_PRINT_NUM("yy_clickBtnByPrintNum", "【点击打印按钮1次，打印多少张】默认为1张"),
        /**
         * 【预约成功后自动打印条码，1次打印多少张】默认为1张
         */
        AUTO_PRINT_NUM_AFTER_SCHEDULE("yy_autoPrintNumAfterSchedule", "【预约成功后自动打印条码，1次打印多少张】默认为1张"),
        /**
         * 【可根据[检查项目]预约成功后自动打印一次性打印多少张】
         */
        AUTO_PRINT_NUM_BY_ITEM("yy_autoPrintNumByItem", "【可根据[检查项目]预约成功后自动打印一次性打印多少张】"),
        IS_SCAN_BTN_BY_SCHEDULE_SIGN("yy_isScanBtnByScheduleSign", ""),
        /**
         * 【预约当前时段的号源时根据当前时间动态减少号源】(1：关闭   0：启用)
         */
        IS_DYNAMIC_SOURCE("yy_isDynamicSource", "【预约当前时段的号源时根据当前时间动态减少号源】(1：关闭   0：启用)"),
        /**
         * 【取消【最早报到时间】【最晚报到时间】【时段结束时间】对报到时间的限制】(1：关闭   0：启用)
         */
        IS_SIGNIN_TIME_NO_LIMIT("yy_isSignInTimeNoLimit", "【取消【最早报到时间】【最晚报到时间】【时段结束时间】对报到时间的限制】(1：关闭   0：启用)"),
        /**
         * 【报到成功后执行扣费的类别】(多个用英文逗号“,”分隔)
         */
        CHARGE_AFTER_EXAM_CLASS_BY_SIGN("yy_chargeAfterExamClassBySign", "【报到成功后执行扣费接口链接】"),
        /**
         * 【报到成功后执行扣费】(1：关闭   0：启用)，noChargeExamClass：表示不需要扣费的检查类别
         */
        IS_CHARGE_AFTER_SIGN("yy_isChargeAfterSign", ""),
        IS_SCHEDULE_INTERVAL_BY_SIGN("yy_isScheduleIntervalBySign", ""),
        IS_SCANNER_AFTER_SIGN("yy_isScannerAfterSign", ""),
        /**
         * 【预约当天立即报到提示】(1：关闭   0：启用)，isScheduleApmTodayBySign：表示是否启用根据可报到时间范围弹出提示；isConfirmSignByIgnoreDialog：表示是否启用跳过预约当天立即报到弹窗，直接报到
         */
        IS_SCHEDULE_TODAY_BY_SIGN("yy_isScheduleTodayBySign", "【预约当天立即报到提示】(1：关闭   0：启用)，isScheduleApmTodayBySign：表示是否启用根据可报到时间范围弹出提示；isConfirmSignByIgnoreDialog：表示是否启用跳过预约当天立即报到弹窗，直接报到"),
        /**
         * 【报到后弹出预约报到信息】(1：关闭   0：启用)
         */
        IS_SHOW_INFO_DIALOG_BY_SIGN("yy_isShowInfoDialogBySign", "【报到后弹出预约报到信息】(1：关闭   0：启用)"),
        /**
         * 【预约凌晨（00:00~03:00）的可提前报到时间】(1：关闭   0：启用)，advanceHour：表示可提前报到小时数
         */
        IS_ADVANCE_TIME_FOR_NIGHT_SIGN("yy_isAdvanceTimeForNightSign", "【预约凌晨（00:00~03:00）的可提前报到时间】(1：关闭   0：启用)，advanceHour：表示可提前报到小时数"),
        IS_SIGN_SCHEDULE_BY_THIRD_WS("yy_isSignScheduleByThirdWS", "【通过第三方RIS提供的接口报到】(1：关闭   0：启用)，signExamClass：表示报到类别，signUrl：表示报到接口地址，cancelUrl：表示取消报到接口地址，queueNoSub：表示第三方报到接口返回排队号截取位置"),
        /**
         * 预约生成排队号
         */
        IS_TAKE_NO_QUEUE("yy_isTakeNoQueue", "【预约后就取号】(1：关闭   0：启用)，openPatientSource：表示开放的病人来源，openQueue：表示开放的队列"),
        PRINT_TICKET_AFTER_SIGN("yy_printTicketAfterSign", "【报到成功后，可根据终端类型、检查类别、病人来源自动打印报到凭条】printTicketTerminalType：表示报到凭条终端类型；printTicketExamClass：表示报到凭条检查类别；printTicketPatientSource：表示报到凭条病人来源；"),
        SIGNIN_OVERTIME_CNT("yy_signin_overtime_cnt", ""),
        /**
         * 【是否启用取消报到调用退费接口】(1：关闭   0：启用)，recedeCostUrl：表示第三方退费接口的链接地址
         */
        IS_RECEDE_COST_BY_RESET("yy_isRecedeCostByReSet", "【是否启用取消报到调用退费接口】(1：关闭   0：启用)，recedeCostUrl：表示第三方退费接口的链接地址"),
        /**
         * 【报到成功后执行扣费接口链接】注：使用的前提是[yy_chargeAfterExamClassBySign]该配置项已配置了检查类别！
         */
        CHARGE_AFTER_SIGN_URL("yy_chargeAfterSignUrl", "【报到成功后执行扣费接口链接】注：使用的前提是[yy_chargeAfterExamClassBySign]该配置项已配置了检查类别！"),

        /**
         * 【是否启用报到时判断确费】（1：关闭   0：启用）
         */
        IS_CONFIRM_FEE_BEFORE_SIGN("yy_isConfirmFeeBeforeSign", "【是否启用报到时判断确费】（1：关闭   0：启用）"),
        /**
         * 【报到时调用确费链接】注：使用的前提是[yy_isConfirmFeeBeforeSign]该配置项要启用！
         */
        CONFIRM_FEE_BEFORE_SIGN_URL("yy_confirmFeeBeforeSignUrl", "【报到时调用确费链接】注：使用的前提是[yy_isConfirmFeeBeforeSign]该配置项要启用！"),
        /**
         * 【根据检查类别报到时确费】注：使用的前提是[yy_isConfirmFeeBeforeSign]该配置项要启用！
         */
        CONFIRM_FEE_BEFORE_SIGN_EXAM_CLASS("yy_confirmFeeBeforeSignExamClass", "【根据检查类别报到时确费】注：使用的前提是[yy_isConfirmFeeBeforeSign]该配置项要启用！"),
        /**
         * 【根据病人来源报到时确费】注：使用的前提是[yy_isConfirmFeeBeforeSign]该配置项要启用！
         */
        CONFIRM_FEE_BEFORE_SIGN_PATIENT_SOURCE("yy_confirmFeeBeforeSignPatientSource", "【根据病人来源报到时确费】注：使用的前提是[yy_isConfirmFeeBeforeSign]该配置项要启用！"),

        REMIND_PRINT_TICKET_AFTER_SIGN("yy_remindPrintTicketAfterSign", "【报到成功后，可根据终端类型、检查类别、病人来源提醒是否要打印凭条】printTicketTerminalType：表示报到凭条终端类型；printTicketExamClass：表示报到凭条检查类别；printTicketPatientSource：表示报到凭条病人来源；"),
        FREE_SOURCE_BY_EARLY_SIGN("yy_freeSourceByEarlySign", "【号源提前释放（预约系统的数据被提前登记或报到检查）】examClass：表示提前报到释放号源的检查类别；leadTime：表示提前时间（界面选什么，就怎样去存进数据库）；"),
        PRINT_BY_EXAM_NO("yy_PrintByExamNo", ""),
        /**
         * 【根据检查类别设置报到按钮不可点击】(多个用英文逗号“,”分隔)
         */
        NO_CLICK_SIGN_BTN_BY_EXAM_CLASS("yy_noClickSignBtnByExamClass", "【根据检查类别设置报到按钮不可点击】(多个用英文逗号“,”分隔)"),
        /**
         * 【允许重复报到取号的类别】(多个用英文逗号“,”分隔) - 自助机
         */
        REPEAT_SIGN_BY_EXAM_CLASS("yy_repeatSignByExamClass", "【允许重复报到取号的类别】(多个用英文逗号“,”分隔)"),

        ADVANCE_TIME_TYPE_BY_SCHEDULE_PRINT("yy_advanceTimeTypeBySchedulePrint", "【预约凭条提示报到时间类型】0：预约时段的前半区间（包含是否设置最早报到时间），如2017-02-10 08:00前  1：时段范围类，如2017-02-10 08:00~08:30  2：实际可报到时间范围（包含是否设置最晚报到时间），如2017-02-10 08:00~09:00"),

        /**
         * 【高拍仪文件上传FTP配置】address：FTP服务器ip地址，port：FTP端口号
         */
        FTP_CONFIG("yy_ftpConfig", "【高拍仪文件上传FTP配置】address：FTP服务器ip地址，port：FTP端口号"),
        IS_SYSTEM_MESSAGE_BOARD("yy_isSystemMessageBoard", ""),
        IS_READ_CARD("yy_isReadCard", ""),
        /**
         * 【删除检查主表exams记录的方式】(0：修改状态为“00” 1：直接删除检查记录)
         * todo 没有实现
         */
        DELETE_EXAMS_TYPE("yy_deleteExamsType", "【删除检查主表exams记录的方式】(0：修改状态为“00” 1：直接删除检查记录)"),
        IS_CHARGE_URL("yy_isChargeUrl", ""),
        /**
         * 【定时任务】（单位：分钟），taskName：任务名，cron：任务执行间隔时间 methodName:releaseLockRun(释放锁定),noCheckRun(出院未检查),noPayRun(非住院未缴费),noSignRun(超时未报到),advanceSignRun(提前登记或提前检查)，state:0 开启，1停用
         * --[{'taskName':'ReleaseScheduleTimeLockTask','cron':'','methodName':'releaseLockRun','state':'0'},{'taskName':'ReleaseScheduleTimeLockTask','cron':'','methodName':'noCheckRun','state':'0'},{'taskName':'ReleaseScheduleTimeLockTask','cron':'','methodName':'noPayRun','state':'1'},{'taskName':'ReleaseScheduleTimeLockTask','cron':'','methodName':'noSignRun','state':'1'},{'taskName':'ReleaseScheduleTimeLockTask','cron':'','methodName':'advanceSignRun','state':'0'}]
         */
        IS_SYS_TASK("yy_isSysTask", "【定时任务】（单位：分钟），taskName：任务名，cron：任务执行间隔时间 methodName:releaseLockRun(释放锁定),noCheckRun(出院未检查),noPayRun(非住院未缴费),noSignRun(超时未报到),advanceSignRun(提前登记或提前检查)，state:0 开启，1停用"),
        PRINT_EXE_URL("yy_printExeUrl", ""),
        /**
         * 【诊断关键字】主要用于维护预约规则里面的关键字模版
         */
        DIAGNOSTIC_KEYWORD("yy_diagnosticKeyword", "【诊断关键字】主要用于维护预约规则里面的关键字模版"),
        CLOUD_FILM_URL("yy_cloudFilmUrl", ""),
        YY_QUERY_YET_EXAMS("yy_isQueryYetExam", ""),
        YY_VISIT_DATE_SORT("yy_isVisitdateSort", ""),
        IS_PRINT_FLAG_BY_TERMINAL("yy_isPrintFlagByTerminal", "【打印标识是否区分终端显示】(0：不区分 1：区分)"),
        YY_LOGINSSOURL("yy_loginSSOUrl", ""),
        /**
         * 【启用显示屏蔽申请单按钮(预约报到界面)】(1：关闭   0：启用)
         */
        IS_SHOW_SHIELD_APPLY_BTN("yy_isShowShieldApplyBtn", "【启用显示屏蔽申请单按钮(预约报到界面)】(1：关闭   0：启用)"),
        /**
         * 【启用显示总号源修改按钮(号源管理界面)】(1：关闭   0：启用)
         */
        IS_SHOW_SOURCE_EDIT_BTN("yy_isShowSourceEditBtn", "【启用显示总号源修改按钮(号源管理界面)】(1：关闭   0：启用)"),

        /**
         * 登录相关的配置项
         */
        LOGIN_CONFIG("yy_LoginConfig", "登录相关的配置"),


        IS_AUTO_TRIAGE("is_auto_triage", ""),
        NO_CONFLICT_EXAM_CLASS("yy_noConflictExamClass", "【管理端预约，可约在同一时段的类别】examClass：设置不想冲突的检查类别，excepClass：与哪些预约在一起不冲突的检查类别"),
        /**
         * 【同患者同天不同类别所约时段之间不发生冲突的时间间隔】（单位：分钟）
         */
        NO_CONFLICT_INTERVAL_TIME("yy_noConflictIntervalTime", "【同患者同天不同类别所约时段之间不发生冲突的时间间隔】（单位：分钟）"),
        /**
         * 【是否启用所有需要镇静的项目不能同一天检查】（1：关闭   0：启用）
         */
        IS_NO_ONE_DAY_CLAM("yy_isNoOneDayClam", "【是否启用所有需要镇静的项目不能同一天检查】（1：关闭   0：启用）"),
        /**
         * 【是否启用所有需要增强的项目不能同一天检查】（1：关闭   0：启用）
         */
        IS_NO_ONE_DAY_ENHANCE("yy_isNoOneDayEnhance", "【是否启用所有需要增强的项目不能同一天检查】（1：关闭   0：启用）"),
        /**
         * 【不能和镇静/增强同一天检查的项目】itemFlag：项目属性（0：该项目不允许预约 1：镇静要求  2：增强项目  3：空腹要求  4：憋尿要求  5：穿刺要求  6：不允许自助报到 7：只允许医技前台预约），examItem：不能同一天检查的项目
         */
        NO_ONE_DAY_CLAM_OR_ENHANCE_ITEM("yy_noOneDayClamOrEnhanceItem", "【不能和镇静/增强同一天检查的项目】itemFlag：项目属性（0：该项目不允许预约 1：镇静要求  2：增强项目  3：空腹要求  4：憋尿要求  5：穿刺要求  6：不允许自助报到 7：只允许医技前台预约），examItem：不能同一天检查的项目"),
        ONE_DAY_ORDER("yy_oneDayOrder", ""),
        /**
         * 【A列表项目比B列表项目至少优先或延后多少天多少小时（项目先后检查及时间设置）】beforeDays：提前多少天数，beforeHours：提前多少小时，afterDays：延后多少天数，afterHours：延后多少小时，examItemA：A列表，examItemB：B列表
         */
        ITEM_BEFORE("yy_itemBefore", "【A列表项目比B列表项目至少优先或延后多少天多少小时（项目先后检查及时间设置）】beforeDays：提前多少天数，beforeHours：提前多少小时，afterDays：延后多少天数，afterHours：延后多少小时，examItemA：A列表，examItemB：B列表"),

        /***
         * 不允许有冲突的时间安排
         */
        IS_NOT_ALLOW_SCHEDULE_BY_CONFLICT("yy_isNotAllowScheduleByConflict", ""),
        YY_CUSTOMEXCEL("yy_customExcel", "【导出清单】"),
        /**
         * 【时段剩余号源】0：显示为时段总剩余号源；1：显示为数量规则计算后实际剩余的号源
         */
        REMAIN_SOURCE_TYPE("yy_remainSourceType", "【时段剩余号源】"),
        YY_CUSTOMEXCEL_SORT_SET("yy_customExcelSortSet", "【导出清单排序设置】"),

        /**
         * 打印清单列表
         */
        YY_PRINT_LIST("yy_printList", "【打印清单】"),
        /**
         * 打印列表排序规则
         */
        YY_PRINT_LIST_SORT_SET("yy_printListSortSet", "【打印清单排序设置】"),
        /**
         * 字体颜色
         */
        FONT_COLOR("yy_fontColor", "【字体颜色】采用十六进制颜色值"),
        CUSTOM_SEARCH_TOOL_BY_SCHEDULE_SIGN("yy_customSearchToolByScheduleSign", "自定义检索栏(预约报到界面)"),
        CUSTOM_TABLE_ROW_BY_SCHEDULE_SIGN("yy_customTableRowByScheduleSign", "自定义表格列(预约报到界面)"),
        CUSTOM_SEARCH_TOOL_BY_MULTIPLE_QUERY("yy_customSearchToolByMultipleQuery", "自定义检索栏(综合查询界面)"),
        CUSTOM_TABLE_ROW_BY_MULTIPLE_QUERY("yy_customTableRowByMultipleQuery", "自定义表格列(综合查询界面)"),
        /**
         * 【统计分析入口】menuName：菜单入口名称；menuUrl：链接地址；examClass：检查类别；
         */
        STATISTICAL_ANALYSIS_ENTRY("yy_statisticalAnalysisEntry", "【统计分析入口】"),
        YY_CUSTOMEXCEL_BY_VIRTUAL_ORDER("yy_customExcelByVirtualOrder", "【虚单导出清单】"),
        YY_CUSTOMEXCEL_BY_REGISTER_RATE_COUNT("yy_customexcelByRegisterRateCount", ""),
        YY_CUSTOMEXCEL_BY_HOSPITAL_RATE_COUNT("yy_customexcelByHospitalRateCount", ""),
        YY_CUSTOMEXCEL_BY_OCCUPY_RATE_COUNT("yy_customexcelByOccupyRateCount", ""),
        YY_CUSTOMEXCEL_BY_DEPT_USER_COUNT("yy_customexcelByDeptUserCount", ""),
        YY_CUSTOMEXCEL_BY_SCHEDULE_COUNT("yy_customexcelByScheduleCount", ""),
        YY_CUSTOMEXCEL_BY_WORK_COUNT("yy_customexcelByWorkCount", ""),
        YY_CUSTOMEXCEL_BY_TERMINAL_TYPE_COUNT("yy_customexcelByTerminalTypeCount", ""),
        YY_CUSTOMEXCEL_BY_BREAK_PROMISE_COUNT("yy_customexcelByBreakPromiseCount", ""),
        YY_CUSTOMEXCEL_SORT_SET_BY_VIRTUAL_ORDER("yy_customExcelSortSetByVirtualOrder", "【虚单导出清单排序设置】"),
        CUSTOM_TABLE_ROW_BY_SCHEDULE_DETAIL("yy_customTableRowByScheduleDetail", "自定义表格列(预约详情界面)"),
        NO_SCHEDULE_ITEM_REMINDER("yy_noScheduleItemReminder", "【不预约的项目(自定义提示语)】"),
        NO_QUERY_EXAM_APPLY_REMINDER("yy_noQueryExamApplyReminder", "【未查询的申请单(自定义提示语)】"),
        NO_QUEUE_BY_EXAM_CLASS_REMINDER("yy_noQueueByExamClassReminder", "【检查类别下无队列(自定义提示语)】"),
        NOT_ALLOW_EDIT_OR_CANCEL_BEFORE_SCHEDULE_REMINDER("yy_notAllowEditOrCancelBeforeScheduleReminder", "【限制预约前一定时间不允许修改和取消预约(自定义提示语)】"),
        CUSTOM_TABLE_ROW_BY_ORDER_MANAGE("yy_customTableRowByOrderManage", "自定义表格列(号源设置界面)"),
        CUSTOM_TABLE_ROW_BY_APPLY_INFO("yy_customTableRowByApplyInfo", "自定义字段(预约报到--申请单内容)"),
        /**
         * 自定义格式配置
         */
        CUSTOM_CONFIG("yy_customConfig", "自定义格式配置"),
        CUSTOM_TABLE_ROW_SORT_SET_BY_SCHEDULE_SIGN("yy_customTableRowSortSetByScheduleSign", "自定义列排序设置(预约报到界面)"),
        CUSTOM_TABLE_ROW_SORT_SET_BY_MULTIPLE_QUERY("yy_customTableRowSortSetByMultipleQuery", "自定义列排序设置(综合查询界面)"),
        /**
         * 【未缴费不能报到(程序控制或报到过程控制)】（1：关闭   0：启用）启用(程序控制)，停用(报到存储过程控制)
         */
        IS_NO_CHARGE_NO_SIGN("yy_isNoChargeNoSign", "【未缴费不能报到(程序控制或报到过程控制)】（1：关闭   0：启用）启用(程序控制)，停用(报到存储过程控制)"),
        NO_SIGN_QUEUE_BY_SELF_REMINDER("yy_noSignQueueBySelfReminder", "【自助机不报到的队列(自定义提示语)】"),
        LIMIT_SCHEDULE_ITEM_BY_TERMINAL_REMINDER("yy_limitScheduleItemByTerminalReminder", "【限制预约终端项目(自定义提示语)】"),
        YY_CURE_CUSTOMEXCEL("yy_cure_customexcel", ""),
        YY_CURE_CUSTOMEXCEL_SORT_SET("yy_cure_customExcelSortSet", ""),
        IS_AUTO_QUERY_BY_SCHEDULE_SIGN("yy_isAutoQueryByScheduleSign", "【是否显示自动查询(预约报到界面)】（1-隐藏；0-显示）"),
        AUTO_QUERY_COUNT_BY_SCHEDULE_SIGN("yy_autoQueryCountByScheduleSign", "【设置默认自动查询秒数(预约报到界面)】"),
        CUSTOM_SEARCH_TOOL_BY_CLINICSCHE("yy_customSearchToolByClinicsche", "自定义检索栏(临床预约-预约报到界面)"),
        CUSTOM_TABLE_ROW_BY_CLINICSCHE("yy_customTableRowByClinicsche", "自定义表格列(临床预约-预约报到界面)"),
        CUSTOM_TABLE_ROW_SORT_SET_BY_CLINICSCHE("yy_customTableRowSortSetByClinicsche", "自定义列排序设置(临床预约-预约报到界面)"),
        CUSTOM_SEARCH_TOOL_BY_DEPTSCHE("yy_customSearchToolByDeptsche", "自定义检索栏(临床预约-综合查询界面)"),
        CUSTOM_TABLE_ROW_BY_DEPTSCHE("yy_customTableRowByDeptsche", "自定义表格列(临床预约-综合查询界面)"),
        CUSTOM_TABLE_ROW_SORT_SET_BY_DEPTSCHE("yy_customTableRowSortSetByDeptsche", "自定义列排序设置(临床预约-综合查询界面)"),
        CUSTOM_TABLE_ROW_SORT_SET_BY_SCHEDULE_SIGN_PATIENT_LIST("yy_customTableRowSortSetByScheduleSignPatientList", "自定义列排序设置(预约报到界面-患者列表)"),
        CUSTOM_TABLE_ROW_SORT_SET_BY_CLINICSCHE_PATIENT_LIST("yy_customTableRowSortSetByClinicschePatientList", "自定义列排序设置(临床预约-预约报到界面-患者列表)"),
        YY_PRINT_LIST_BY_DEPTSCHE("yy_printListByDeptsche", "打印清单(临床预约-综合查询界面)"),
        YY_PRINT_LIST_SORT_SET_BY_DEPTSCHE("yy_printListSortSetByDeptsche", "打印清单排序设置(临床预约-综合查询界面)"),
        YY_CUSTOMEXCEL_BY_DEPTSCHE("yy_customExcelByDeptsche", "导出清单(临床预约-综合查询界面)"),
        YY_CUSTOMEXCEL_SORT_SET_BY_DEPTSCHE("yy_customExcelSortSetByDeptsche", "导出清单排序设置(临床预约-综合查询界面)"),
        LOGIN_LOGO_PIC("yy_loginLogoPic", "【登录页logo图片】数据格式为base64"),
        FRAME_LOGO_PIC("yy_frameLogoPic", "【框架栏logo图片】数据格式为base64"),
        FRAME_NAME("yy_frameName", "【机构文字名称】"),
        CUSTOM_PHONE("yy_customPhone", ""),
        CUSTOM_DEPT_CODE("yy_customDeptCode", "");

        private String key;
        private String value;

        private ConfigName(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }

        public static ConfigName get(String key) {
            ConfigName[] values = values();
            for (ConfigName obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }

        public static String getValue(String key) {
            ConfigName[] values = values();
            for (ConfigName obj : values) {
                if (obj.key.equals(key)) {
                    return obj.value;
                }
            }
            return "";
        }
    }

    public enum CureConfigName {
        SELF_ACT_LIMIT("cure_selfActLimit", ""),
        CUSTOM_PHONE("cure_customPhone", "");

        private String key;
        private String value;

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }

        private CureConfigName(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static CureConfigName get(String key) {
            CureConfigName[] values = values();
            for (CureConfigName obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }
    }

    /**
     * 预约规则枚举
     */
    public enum RegularAttribute {
        VIP("vip", "VIP病人"),
        CLINIC_PATH("clinicPath", "临床路径"),
        BED_SIDE("bedSide", "床边检查"),
        INDOLENCE("indolence", "无痛检查"),
        CRITICALLY_ILL("criticallyIll", "病重病人"),
        CREATE_DOC("createDoc", "本院建档"),
        INFECTIOUS("infectious", "传染病"),
        MULTI_DRUG("multiDrug", "多重耐药"),
        NEED_TO_CALM("needToCalm", "需要镇静"),
        EN_CHANCE("enhance", "增强"),
        CALM("calm", "镇静"),
        EMPTY_STOMACH("emptyStomach", "空腹"),
        BER_NAO("bernao", "憋尿"),
        PUNCTURE("puncture", "穿刺");

        private final String key;
        private final String value;

        RegularAttribute(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }

        //        public static RegularAttribute get(String key) {
//            RegularAttribute[] values;
//            RegularAttribute[] RegularAttributes = values = values();
//            for (RegularAttribute obj : values) {
//                if (obj.key.equals(key)) {
//                    return obj;
//                }
//            }
//            return null;
//        }
    }

    /**
     * 规则类型
     */
    public enum RegularModule {
        REGULAR_SCHEDULE("scheduleRegular", "预约规则"),
        REGULAR_NUMBER("numberRegular", "数量规则");

        private final String key;
        private final String value;

        RegularModule(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }
    }

    public enum ModuleFunction {
        DICT("dict", "0046,0020"),
        QUEUE("queue", "0046,0020,0077"),
        ITEM("item", "0046,0020,0078"),
        REMINDER("reminder", "0046,0020"),
        SMS("sms", "0046,0020"),
        REGULAR("regular", "0046,0073"),
        SOURCE("source", "0046,0073,0086"),
        SOURCE_LOG("sourceLog", "0046,0059,0086"),
        SCHEDULE_LOG("scheduleLog", "0046,0059"),
        BLACKLIST("blackList", "0046,0072"),
        CALL("call", "0046,0074"),
        CANCEL_SOURCE("cancelSource", "0046,0075"),
        REFER_VIP("referVip", "0046,0080"),
        SCHEDULE_VIP("scheduleVip", "0046,0080"),
        EDIT_QUEUE_MULTI("editQueueMulti", "0046,0080"),
        CONFIRM("confirm", "0081"),
        SIGN("sign", "0046,0082"),
        EXAM_REFER("examRefer", "0046,0087"),
        SCHEDULE("schedule", "0046,0001,0002"),
        QUERY("query", "0046,0085"),
        DETAIL("detail", "0046,0005,0091"),
        GROUP("group", "0046,0084");

        public String key;
        public String value;

        private ModuleFunction(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static ModuleFunction get(String key) {
            ModuleFunction[] values;
            ModuleFunction[] moduleFunctions = values = values();
            for (ModuleFunction obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }
    }

    /**
     * 检查状态
     */
    public enum ExamStatus {
        TWENTY("20"),
        FIFTY("50"),
        /**
         * 已签到
         */
        SCHEDULE_TWENTY("10"),
        /**
         * 已检查
         */
        SCHEDULE_FIFTY("40");

        private String status;

        ExamStatus(String status) {
            this.status = status;
        }

        public String getStatus() {
            return this.status;
        }
    }

    /**
     * 自助机相关配置属性
     */
    public enum SelfConfigName {
        SELF_SCHEDULE_EXAM_CLASS("yy_self_scheduleExamClass", "自助机---预约检查类别"),
        SELF_SIGN_EXAM_CLASS("yy_self_signExamClass", "自助机---报到检查类别"),
        SELF_DIRECT_CLASS("yy_self_directClass", "自助机---无需预约直接报到检查类别"),
        SELF_UN_SCHEDULE_PATIENT_SOURCE("yy_self_unSchedulePatientSource", "自助机---不能在自助机预约的病人来源"),
        SELF_UN_SIGN_QUEUE("yy_self_unSignQueue", "自助机---不能在自助机报到的队列"),
        SELF_IS_SCHEDULE_PLAN("yy_self_isSchedulePlan", "自助机---是否开启预约计划"),
        SELF_IS_READ_CARD("yy_self_isReadCard", "自助机---是否开启读卡"),
        SELF_IS_SIGN_NOW("yy_self_isSignNow", "自助机---是否开启立即报到"),
        SELF_PRINTER_NAME("yy_self_printerName", "自助机---打印机名称"),
        SELF_FUNCTION_BUTTON("yy_self_functionButton", "自助机---引导页功能模块"),
        SELF_SCHEDULE_QUEUE("yy_self_scheduleQueue", "自助机---能在自助机预约的队列"),
        SELF_SIGN_QUEUE("yy_self_signQueue", "自助机---能在自助机报到的队列"),
        SELF_IC_CARD_INPUT_SUPPORT_TYPE("yy_self_icCardInputSupportType", "自助机---输入卡号框对应的卡号类型");

        private String key;
        private String value;

        SelfConfigName(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static SelfConfigName get(String key) {
            SelfConfigName[] values;
            SelfConfigName[] selfConfigNames = values = values();
            for (SelfConfigName obj : values) {
                if (obj.key.equals(key)) {
                    return obj;
                }
            }
            return null;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }
    }

    public enum SelfFunction {
        TAKE_NO("F01", "心电取号"),
        SCHEDULE("F02", "检查预约"),
        SIGN("F03", "报到取号"),
        WAIT("F04", "候诊查询"),
        REPORT("F05", "自助报告");

        public String key;
        public String value;

        SelfFunction(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static SelfFunction get(String key) {
            return Arrays.stream(values()).filter(x -> x.key.equals(key))
                    .findFirst().orElse(null);
        }
    }

    /***
     * 短信类型
     */
    public enum SmsType {
        SCHEDULE("3"),
        SIGNIN("5"),
        UPDATE("7"),
        CANCLE_SCHEDULE("6");

        private String type;

        private SmsType(String type) {
            this.type = type;
        }

        public String getType() {
            return this.type;
        }
    }

    /**
     * 终端类型
     */
    public enum TerminalTypeSchePath {
        // 科室端
        DEPT("01", "A"),
        // 临床-住院
        CLINIC_IN("02", "B"),
        // 自助机
        SELF("03", "C"),
        // 移动端
        MOBILE("04", "D"),
        // 预约中心
        SCHEDULE_CENTER("05", "E"),
        NO_REGULAR("99", "R"),
        // 临床-门诊
        CLINIC_OUT("06", "H");

        public String key;
        private String value;

        TerminalTypeSchePath(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static TerminalTypeSchePath get(String key) {
            return Arrays.stream(values()).filter(x -> x.key.equals(key))
                    .findFirst().orElse(null);
        }

        public static String getValue(String key) {
            TerminalTypeSchePath schePath = get(key);

            if (Objects.nonNull(schePath)) {
                return schePath.value;
            }
            return null;
        }

        public static String getKey(String value) {
            TerminalTypeSchePath schePath = Arrays.stream(values())
                    .filter(x -> x.value.equals(value))
                    .findFirst().orElse(null);
            if (Objects.nonNull(schePath)) {
                return schePath.key;
            }
            return null;
        }
    }

    public enum DateFormat {
        DATE("DATE", "yyyy-MM-dd"),
        MONTH("MONTH", "yyyy-MM"),
        YEAR("YEAR", "yyyy");

        private String key;
        private String value;

        DateFormat(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static String getValue(String key) {
            DateFormat[] values;
            DateFormat[] sps = values = values();
            for (DateFormat sp : values) {
                if (sp.key.equals(key)) {
                    return sp.value;
                }
            }
            return null;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }
    }

    /***
     * 患者支持的查询方式
     */
    public enum PatientDomainId {
        SICK_ID("sick_id", "0001", ""),
        /**
         * 身份证号
         */
        IDENTITY_CARD("identity_card", "0002", "身份证号"),
        /**
         * 医保卡号
         */
        MI_CARD("mi_card", "0003", "医保卡号"),
        /**
         * 医保码号
         */
        MI_ID("mi_id", "0004", "医保码号"),
        MEDICAL_CARD("medical_card", "0005", ""),
        MEDICAL_ID("medical_id", "0006", ""),
        IC_CARD("ic_card", "0007", ""),
        IC_ID("ic_id", "0008", ""),
        HEALTH_CARD("health_card", "0009", ""),
        HEALTH_ID("health_id", "0010", ""),
        PHONE_NUMBER("phone_number", "0011", ""),
        OUTPATIENT_NO("outpatient_no", "0012", ""),
        OUT_REG_NO("out_reg_no", "0013", ""),
        INPATIENT_NO("inpatient_no", "0014", ""),
        VISIT_ID("visit_id", "0015", ""),
        CASE_NO("case_no", "0016", ""),
        SCHEDULE_ID("schedule_id", "0017", ""),
        EXAM_NO("exam_no", "0018", ""),
        COMMON_CARD("common_card", "", ""),
        APPLY_NO("apply_no", "", "");

        public String key;
        public String value;
        private String name;

        PatientDomainId(String key, String value, String name) {
            this.key = key;
            this.value = value;
            this.name = name;
        }

        public String getKey() {
            return key;
        }


        public String getValue() {
            return value;
        }

        public String getName() {
            return name;
        }

        public static PatientDomainId get(String key) {
            return Arrays.stream(values()).filter(x -> x.key.equals(key))
                    .findFirst().orElse(null);
        }
    }

    public enum ClassAttr {
        EXAM("0"),
        CURE("1"),
        SURGERY("2"),
        BED("3");

        private String type;

        private ClassAttr(String type) {
            this.type = type;
        }

        public String getType() {
            return this.type;
        }
    }

    /**
     * @author ryan.li
     * @description 检查项目分组  分组类别
     * @date 2022/10/21 11:56
     */
    public enum GroupType {
        /**
         * 合单分组
         */
        ZERO("0", "合单分组"),
        /**
         * 拆单分组
         */
        ONE("1", "拆单分组"),
        /**
         * 预约规则
         */
        TWO("2", "预约规则"),
        /**
         * 组合系数
         */
        THREE("3", "组合系数"),
        /**
         * 依赖分组
         */
        FOUR("4", "依赖分组"),
        /**
         * 互斥分组
         */
        FIVE("5", "互斥分组"),
        /**
         * 合单分组
         */
        SIX("6", "合单分组");

        private String key;
        private String value;

        GroupType(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public static GroupType get(String key) {
            return Arrays.stream(values()).filter(x -> x.key.equals(key)).findFirst().orElse(null);
        }

        public static String getValue(String key) {
            GroupType groupType = Arrays.stream(values()).filter(x -> x.key.equals(key)).findFirst().orElse(null);
            if (Objects.isNull(groupType)) {
                return null;
            }
            return groupType.value;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }
    }

    public enum NettyMsgCode {
        YY_ONE("yy001"),
        YY_TOW("yy002"),
        YY_CALL("yy003");

        private String code;

        private NettyMsgCode(String code) {
            this.code = code;
        }

        public String getCode() {
            return this.code;
        }
    }

    public enum NoticeType {
        CONFIRM("23"),
        UPDATE("24"),
        CANCEL("25");

        private String type;

        private NoticeType(String type) {
            this.type = type;
        }

        public String getType() {
            return this.type;
        }
    }

    /**
     * 申请单缴费状态
     */
    public enum ChargeFlags {
        NO_PAY("0", "未缴费"),
        PAID("1", "已缴费"),
        REFUNDING("2", "申请退费"),
        REFUNDED("3", "已退费");
        private String code;
        private String desc;

        ChargeFlags(String code, String desc) {
            this.code = code;
            this.desc = desc;
        }

        public String getCode() {
            return code;
        }

        public String getDesc() {
            return desc;
        }
    }

    /**
     * 预约规则类型
     */
    public enum ScheduleRegularType {
        SCHEDULE("0", "预约规则"),
        NUMBER("3", "数量规则");


        private String key;
        private String value;

        ScheduleRegularType(String key, String value) {
            this.key = key;
            this.value = value;
        }

        public String getKey() {
            return key;
        }

        public String getValue() {
            return value;
        }
    }

    /**
     * 时段字典数据启用停用状态
     */
    public enum DictAPMUseStatus {
        /**
         * 启用状态
         */
        TRUE("t"),
        /**
         * 停用状态
         */
        FALSE("f"),
        ;

        DictAPMUseStatus(String code) {
            this.code = code;
        }

        private final String code;

        public String getCode() {
            return code;
        }
    }

    /**
     * 时段字典数据启用停用状态
     */
    public enum DictAPMStopFlag {
        /**
         * 启用状态
         */
        ENABLE("0"),
        /**
         * 停用状态
         */
        STOP("1"),
        /**
         * 删除状态
         */
        DEL("2"),
        ;

        DictAPMStopFlag(String code) {
            this.code = code;
        }

        private final String code;

        public String getCode() {
            return code;
        }
    }
}
